home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 25 / Cream of the Crop 25.iso / os2 / sets11.zip / Sets.CPP next >
C/C++ Source or Header  |  1997-04-09  |  5KB  |  213 lines
  1. // Sets v 1.1
  2. // Hubert Chan, April 9, 1997
  3.  
  4. #include "Sets.HPP"
  5.  
  6. static int counter;
  7. #define DOONWHOLEARRAY(x) for(counter = 0; counter < SETELEMENTSIZE; counter++) x
  8.  
  9. Set::Set(Set& Set2) {
  10.     DOONWHOLEARRAY(SetElements[counter] = Set2.SetElements[counter]);
  11. }
  12.  
  13. void Set::AddElem(SetElement Element) {
  14.     int Segment = (Element - MINELEMENT) / 8,
  15.         Offset  = (Element - MINELEMENT) % 8;
  16.  
  17.     SetElements[Segment] |= 1 << Offset;
  18. }
  19.  
  20. void Set::RemoveElem(SetElement Element) {
  21.     int Segment = (Element - MINELEMENT) / 8,
  22.         Offset  = (Element - MINELEMENT) % 8;
  23.  
  24.     SetElements[Segment] &= ~(1 << Offset);
  25. }
  26.  
  27. void Set::ClearSet() {
  28.     DOONWHOLEARRAY(SetElements[counter] = 0);
  29. }
  30.  
  31. Set Set::operator=(Set Set2) {
  32.     DOONWHOLEARRAY(SetElements[counter] = Set2.SetElements[counter]);
  33.     return *this;
  34. }
  35.  
  36. Set Set::operator+(Set Set2) {
  37.     Set Result;
  38.     DOONWHOLEARRAY(Result.SetElements[counter] = SetElements[counter] | Set2.SetElements[counter]);
  39.     return Result;
  40. }
  41.  
  42. Set Set::operator|(Set Set2) {
  43.     return (*this + Set2);
  44. }
  45.  
  46. Set Set::operator+(SetElement Element) {
  47.     Set Result = *this;
  48.     Result.AddElem(Element);
  49.     return Result;
  50. }
  51.  
  52. Set Set::operator|(SetElement Element) {
  53.     return (*this + Element);
  54. }
  55.  
  56. Set Set::operator+=(Set Set2) {
  57.     DOONWHOLEARRAY(SetElements[counter] |= Set2.SetElements[counter]);
  58.     return *this;
  59. }
  60.  
  61. Set Set::operator|=(Set Set2) {
  62.     return (*this += Set2);
  63. }
  64.  
  65. Set Set::operator+=(SetElement Element) {
  66.     AddElem(Element);
  67.     return *this;
  68. }
  69.  
  70. Set Set::operator|=(SetElement Element) {
  71.     return (*this += Element);
  72. }
  73.  
  74. Set Set::operator-() {
  75.     Set Result;
  76.     DOONWHOLEARRAY(Result.SetElements[counter] = ~SetElements[counter]);
  77.     return Result;
  78. }
  79.  
  80. Set Set::operator~() {
  81.     return -(*this);
  82. }
  83.  
  84. Set Set::operator*(Set Set2) {
  85.     Set Result;
  86.     DOONWHOLEARRAY(Result.SetElements[counter] = SetElements[counter] & Set2.SetElements[counter]);
  87.     return Result;
  88. }
  89.  
  90. Set Set::operator^(Set Set2) {
  91.     return (*this * Set2);
  92. }
  93.  
  94. Set Set::operator&(Set Set2) {
  95.     return (*this * Set2);
  96. }
  97.  
  98. Set Set::operator*=(Set Set2) {
  99.     DOONWHOLEARRAY(SetElements[counter] &= Set2.SetElements[counter]);
  100.     return *this;
  101. }
  102.  
  103. Set Set::operator^=(Set Set2) {
  104.     return (*this *= Set2);
  105. }
  106.  
  107. Set Set::operator&=(Set Set2) {
  108.     return (*this *= Set2);
  109. }
  110.  
  111. Set Set::operator-(Set Set2) {
  112.     Set Result;
  113.     DOONWHOLEARRAY(Result.SetElements[counter] = SetElements[counter] & (~Set2.SetElements[counter]));
  114.     return Result;
  115. }
  116.  
  117. Set Set::operator-(SetElement Element) {
  118.     Set Result = *this;
  119.     Result.RemoveElem(Element);
  120.     return Result;
  121. }
  122.  
  123. Set Set::operator-=(Set Set2) {
  124.     DOONWHOLEARRAY(SetElements[counter] &= !Set2.SetElements[counter]);
  125.     return *this;
  126. }
  127.  
  128. Set Set::operator-=(SetElement Element) {
  129.     RemoveElem(Element);
  130.     return *this;
  131. }
  132.  
  133. int Set::operator==(Set Set2) {
  134.     int Equivalent = -1;
  135.     DOONWHOLEARRAY(Equivalent &= (SetElements[counter] == Set2.SetElements[counter]));
  136.     return Equivalent;
  137. }
  138.  
  139. int Set::operator!=(Set Set2) {
  140.     int NotEquivalent = 0;
  141.     DOONWHOLEARRAY(NotEquivalent |= (SetElements[counter] != Set2.SetElements[counter]));
  142.     return (NotEquivalent != 0);
  143. }
  144.  
  145. int Set::operator<=(Set Set2) {
  146.     int Subset = -1;
  147.     DOONWHOLEARRAY(Subset &= (~SetElements[counter] | Set2.SetElements[counter]));
  148.     return (Subset == -1);
  149. }
  150.  
  151. int Set::operator<(Set Set2) {
  152.     int Subset = 0;
  153.     DOONWHOLEARRAY(Subset |= (SetElements[counter] != Set2.SetElements[counter]));
  154.     Subset = (Subset != 0 ) ? -1 : 0;
  155.     DOONWHOLEARRAY(Subset &= (~SetElements[counter] | Set2.SetElements[counter]));
  156.     return (Subset == -1);
  157. }
  158.  
  159. int Set::operator>=(Set Set2) {
  160.     int Superset = -1;
  161.     DOONWHOLEARRAY(Superset &= (SetElements[counter] | ~Set2.SetElements[counter]));
  162.     return (Superset == -1);
  163. }
  164.  
  165. int Set::operator>(Set Set2) {
  166.     int Superset = 0;
  167.     DOONWHOLEARRAY(Superset |= (SetElements[counter] != Set2.SetElements[counter]));
  168.     Superset = (Superset != 0) ? -1 : 0;
  169.     DOONWHOLEARRAY(Superset &= (SetElements[counter] | ~Set2.SetElements[counter]));
  170.     return (Superset == -1);
  171. }
  172.  
  173. int operator<=(Set::SetElement Element, Set Set2) {
  174.     int Segment = (Element - MINELEMENT) / 8,
  175.         Offset  = (Element - MINELEMENT) % 8;
  176.  
  177.     return ((Set2.SetElements[Segment] & (1 << Offset)) != 0);
  178. }
  179.  
  180. //ostream & operator<<(ostream & s, Set & Set2) {
  181. //    Set::SetElement counter;
  182. //    int NotFirst = 0;
  183. //    s << "{ ";
  184. //    for(counter = MINELEMENT; counter <= MAXELEMENT; counter++)
  185. //        if (counter <= Set2)
  186. //            if (NotFirst)
  187. //                s << form(",%d",counter);
  188. //            else {
  189. //                s << form("%d",counter);
  190. //                NotFirst = !0;
  191. //            }
  192. //    s << " }";
  193. //    return s;
  194. //}
  195.  
  196. #include <StdIO.h>
  197.  
  198. void PrintSet(Set &Set1) {
  199.     Set::SetElement counter;
  200.     int NotFirst = 0;
  201.     printf("{ ");
  202.     for(counter = MINELEMENT; counter <= MAXELEMENT; counter++)
  203.         if (Set1 >= counter)
  204.             if (NotFirst)
  205.                 printf(",%d",counter);
  206.             else {
  207.                 printf("%d",counter);
  208.                 NotFirst = -1;
  209.             }
  210.     printf(" }\n");
  211. }
  212.  
  213.